Unit-1,2,3 Extra Programs

size = int(input( 'Enter size  = '))
for i in range(1, size):
    for j in range(1,size):
        if (i==j):
            print('$', end = " ")
        elif(i==1 or i==(size-1) or j==1 or j==(size-1)):
             print("*", end=" ")
        else:
             print(" ", end = " ")
    print('\n')

def solve(n):
   for i in range(n+1):
      for j in range(n-i):
         print(' ', end='')

      C = 1
      for j in range(1, i+1):
         print(C, ' ', sep='', end='')
         C = C * (i - j) // j
      print()

n = 5
solve(n)

def make_change(amount):
    remaining_cents = int(amount * 100)

    quarters = remaining_cents // 25
    remaining_cents %= 25

    dimes = remaining_cents // 10
    remaining_cents %= 10

    nickels = remaining_cents // 5
    remaining_cents %= 5

    pennies = remaining_cents

    print("Quarters:", quarters)
    print("Dimes:", dimes)
    print("Nickels:", nickels)
    print("Pennies:", pennies)

# Get user input for the amount of change
change_amount = float(input("Enter the amount of change (less than $1.00): "))

# Call the function to calculate and print the change
make_change(change_amount)

def compute_sum():
    total_sum = 0
    for i in range(1, 2001):
        if i % 2 == 0:
            total_sum -= i
        else:
            total_sum += i
    return total_sum

result = compute_sum()
print("The sum 1-2+3-4+...+1999-2000 is:", result)

def int_to_roman(num):
    thousands = num // 1000
    num %= 1000
    hundreds = num // 100
    num %= 100
    tens = num // 10
    ones = num % 10

    roman_numeral = 'M' * thousands

    if hundreds == 9:
        roman_numeral += 'CM'
    elif hundreds >= 5:
        roman_numeral += 'D' + 'C' * (hundreds - 5)
    elif hundreds == 4:
        roman_numeral += 'CD'
    else:
        roman_numeral += 'C' * hundreds

    if tens == 9:
        roman_numeral += 'XC'
    elif tens >= 5:
        roman_numeral += 'L' + 'X' * (tens - 5)
    elif tens == 4:
        roman_numeral += 'XL'
    else:
        roman_numeral += 'X' * tens

    if ones == 9:
        roman_numeral += 'IX'
    elif ones >= 5:
        roman_numeral += 'V' + 'I' * (ones - 5)
    elif ones == 4:
        roman_numeral += 'IV'
    else:
        roman_numeral += 'I' * ones

    return roman_numeral

# Test the function
number = int(input("Enter an integer: "))
roman_result = int_to_roman(number)
print(f"The Roman numeral for {number} is: {roman_result}")

def calculate_bill_amount(quantity, value, discount, tax):
    total_cost = quantity * value
    discounted_cost = total_cost - (total_cost * discount / 100)
    total_amount = discounted_cost + (discounted_cost * tax / 100)
    return total_amount

# Get input from the user
quantity = float(input("Enter the quantity sold: "))
value = float(input("Enter the value of the item: "))
discount = float(input("Enter the discount percentage: "))
tax = float(input("Enter the tax percentage: "))

# Calculate and display the bill amount
bill_amount = calculate_bill_amount(quantity, value, discount, tax)
print(f"The total bill amount is: {bill_amount}")

def GCD(x,y):
    rem = x%y
    if (rem==0):
        return y
    else:
        return GCD(y,rem)
n = int(input ("Enter the first number : "))
m = int(input ("Enter the second number : "))
print(f"The GCD of numbers {n} and {m} is {GCD(n,m)}")

def fact(n):
    f = 1
    if(n==0 or n==1):
        return 1
    else:
        for i in range(1, int(n+1)):
            f=f*i
    return f

n = int(input('Enter the value of n : '))
s = 0.0
for i in range(1,n+1):
    s = s+(float(i**i)/fact(i))
print("Result :",s)

def solve(n):
   s = 28
   res = 0
   if n>7:
      res = s
      div = n//7
      for i in range(1,div):
         res += s+7*i
      rem = n % 7
      for i in range(1,rem+1):
         res += i+div
   else:
      for i in range(1,n+1):
         res+=i
   return res

n = 17
print(solve(n))

# Function to calculate the sum of a geometric series
def geometric_series_sum(r, n):
    return 1 / (1 - r)

# Common ratio for the series
common_ratio = 1/2

# Number of terms in the series (adjust as needed)
num_terms = 1000

# Calculate the sum of the geometric series
sum_result = geometric_series_sum(common_ratio, num_terms)

print(f"The sum of the series is: {sum_result}")

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

def nth_prime_number(n):
    prime_count = 0
    num = 2

    while True:
        if is_prime(num):
            prime_count += 1
            if prime_count == n:
                return num
        num += 1

# Find the 10th prime number as an example
nth_prime = 15
result = nth_prime_number(nth_prime)

print(f"The {nth_prime}th prime number is: {result}")

n = int ( input ( "Enter the value of n : " ))
s = 0.0
for i in range(1,n+1):
    a = float(i**i)/i
    s = s+a
print(f'The sum of the series is ',s)

def find_smallest_number():
    number = 1
    found = False
    
    while not found:
        found = True
        for i in range(1, 11):
            if number % i != 0:
                found = False
                break
        if not found:
            number += 1

    return number

result = find_smallest_number()
print("The smallest positive number divisible by integers from 1 to 10 is:", result)

def gcd(x, y):
    # Calculate the greatest common divisor using Euclidean algorithm
    while y:
        x, y = y, x % y
    return x

def reduce_fraction(numerator, denominator):
    # Find the greatest common divisor
    common_divisor = gcd(numerator, denominator)

    # Reduce the fraction by dividing both numerator and denominator by the common divisor
    reduced_numerator = numerator // common_divisor
    reduced_denominator = denominator // common_divisor

    return reduced_numerator, reduced_denominator

# Input numerator and denominator
numerator = int(input("Enter the numerator: "))
denominator = int(input("Enter the denominator: "))

# Check if the fraction is valid (denominator should not be zero)
if denominator != 0:
    # Reduce the fraction
    reduced_numerator, reduced_denominator = reduce_fraction(numerator, denominator)

    # Display the reduced fraction
    print(f"The reduced fraction is: {reduced_numerator}/{reduced_denominator}")

else:
    print("Invalid fraction. Denominator cannot be zero.")

def babylonian_sqrt(number, iterations=10):
    guess = number / 2  # Initial guess

    for _ in range(iterations):
        # Update the guess using the Babylonian method formula
        guess = 0.5 * (guess + number / guess)

    return guess

# Input a number from the user
number = float(input("Enter a number to find its square root: "))

# Check if the number is non-negative
if number >= 0:
    # Calculate and print the square root using the Babylonian method
    square_root = babylonian_sqrt(number)
    print(f"The square root of {number} is approximately: {square_root}")
else:
    print("Invalid input. Please enter a non-negative number.")

def are_all_digits_even(num):
    while num > 0:
        digit = num % 10
        if digit % 2 != 0:
            return False
        num //= 10
    return True

def find_and_print_even_digit_numbers(start, end):
    first = True
    for i in range(start, end + 1):
        if are_all_digits_even(i):
            if not first:
                print(",", end="")
            first = False
            print(i, end="")
    print()

start_range = 1000
end_range = 3000
find_and_print_even_digit_numbers(start_range, end_range)

def pells_equation():
    for x in range(1, 101):
        for y in range(1, 101):
            if x**2 - 2*y**2 == 1:
                print(f"Integer solution: x = {x}, y = {y}")

# Find and print solutions
pells_equation()

def factorial(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

def is_strong_number(number):
    sum_of_factorials = 0
    temp_number = number

    while temp_number > 0:
        digit = temp_number % 10
        sum_of_factorials += factorial(digit)
        temp_number //= 10

    return sum_of_factorials == number

# Input from user
start_range = int(input("Enter the starting number of the range: "))
end_range = int(input("Enter the ending number of the range: "))

# Print strong numbers within the specified range
strong_numbers_found = False
print(f"Strong numbers between {start_range} and {end_range} are:")
for num in range(start_range, end_range + 1):
    if is_strong_number(num):
        print(num, end=" ")
        strong_numbers_found = True

# Check if any strong numbers were found
if not strong_numbers_found:
    print(f"There are no strong numbers between {start_range} and {end_range}.")

def sum_of_divisors(number):
    divisors_sum = 0
    for divisor in range(1, number):
        if number % divisor == 0:
            divisors_sum += divisor
    return divisors_sum

def are_amicable_numbers(num1, num2):
    return sum_of_divisors(num1) == num2 and sum_of_divisors(num2) == num1

# Input from user
start_range = int(input("Enter the starting number of the range: "))
end_range = int(input("Enter the ending number of the range: "))

# Find and print amicable number pairs within the specified range
amicable_pairs_found = False
print(f"Amicable number pairs between {start_range} and {end_range} are:")
for num1 in range(start_range, end_range + 1):
    for num2 in range(num1 + 1, end_range + 1):
        if are_amicable_numbers(num1, num2):
            print(f"({num1}, {num2})", end=" ")
            amicable_pairs_found = True

# Check if any amicable number pairs were found
if not amicable_pairs_found:
    print(f"There are no amicable number pairs between {start_range} and {end_range}.")

def is_perfect_number(number):
    if number <= 0:
        return False
    
    sum_of_divisors = 0
    for divisor in range(1, number):
        if number % divisor == 0:
            sum_of_divisors += divisor
    
    return sum_of_divisors == number

# Input from user
start_range = int(input("Enter the starting number of the range: "))
end_range = int(input("Enter the ending number of the range: "))

# Print perfect numbers within the specified range
perfect_numbers_found = False
print(f"Perfect numbers between {start_range} and {end_range} are:")
for num in range(start_range, end_range + 1):
    if is_perfect_number(num):
        print(num, end=" ")
        perfect_numbers_found = True

# Check if any perfect numbers were found
if not perfect_numbers_found:
    print(f"There are no perfect numbers between {start_range} and {end_range}.")

def is_harshad_number(n):
    # Check if the number is positive
    if n <= 0:
        return False

    # Calculate the sum of digits
    digit_sum = 0
    for digit in str(n):
        digit_sum += int(digit)

    # Check if the number is divisible by the sum of its digits
    return n % digit_sum == 0

# Example usage:
number = int(input("Enter a number: "))
result = is_harshad_number(number)

if result:
    print(f"{number} is a Harshad number.")
else:
    print(f"{number} is not a Harshad number.")

def is_squarefree(num):
    if num < 1:
        return False

    for i in range(2, int(num**0.5) + 1):
        if num % (i**2) == 0:
            return False

    return True

# Get user input
user_integer = int(input("Enter an integer to check if it is squarefree: "))

# Check and print the result
if is_squarefree(user_integer):
    print(f"{user_integer} is squarefree.")
else:
    print(f"{user_integer} is not squarefree.")

for n in range(1, 30):
    res = n

    while res != 1 and res != 4:
        r = s = 0
        while res > 0:
            r = res % 10
            s += r**2
            res //= 10
        
        res = s

    if res == 1:
        print(n, end = " ")
#     elif res == 4:
#         print(f"{n} is not a happy number")

#isPronicNumber() will determine whether a given number is a pronic number or not  
def isPronicNumber(num):  
    flag = False;  
      
    for j in range(1, num+1):  
        #Checks for pronic number by multiplying consecutive numbers  
        if((j*(j+1)) == num):  
            flag = True;  
            break;  
    return flag;  
   
#Displays pronic numbers between 1 and 100  
print("Pronic numbers between 1 and 100: ");  
for i in range(1, 101):  
    if(isPronicNumber(i)):  
        print(i, sep= ",", end=" ")

# Function to calculate the length (number of digits) of a given number
def calculateLength(n):
    length = 0  # Initialize the length variable to zero
    while(n != 0):  # Loop until the number becomes zero
        length = length + 1  # Increment the length for each digit
        n = n // 10  # Remove the last digit from the number
    return length  # Return the calculated length


num = 246  # Example number
rem = sum = 0  # Initialize variables for remainder and sum
len = calculateLength(num)  # Calculate the length of the number

# Make a copy of the original number 'num'
n = num

# Calculate the sum of digits powered with their respective position
while(num > 0):
    rem = num % 10  # Get the last digit of the number
    sum = sum + int(rem ** len)  # Add the digit powered with its position to the sum
    num = num // 10  # Remove the last digit from the number
    len = len - 1  # Decrease the position for the next digit

# Check whether the sum is equal to the original number
if(sum == n):
    print(str(n) + " is a disarium number")  # Print if it's a disarium number
else:
    print(str(n) + " is not a disarium number")  # Print if it's not a disarium number

def ramanujan_On4(limit):
    result = ""

    for a in range(1, limit):
        for b in range(a, limit):
            for c in range(a, limit):
                for d in range(c, limit):

                    x = a ** 3 + b ** 3
                    y = c ** 3 + d ** 3

                    if x == y and (a != c or b != d):
                        number = a ** 3 + b ** 3
                        result += f'{number}: {a, b, c, d}\n'

    return result

L = 20
ra1_str = ramanujan_On4(L)
print(ra1_str)

a = input()
n1 = int(f"{a}")
n2 = int(f"{a}{a}")
n3 = int(f"{a}{a}{a}")
n4 = int(f"{a}{a}{a}{a}")
print(n1 + n2 + n3 + n4)

netAmount = 0
while True:
    s = input()
    if not s:
        break
    
    # Initialize variables for operation and amount
    operation = ""
    amount_str = ""
    is_operation = True

    # Iterate over characters in the input string
    for char in s:
        if char == ' ':
            is_operation = False
        elif is_operation:
            operation += char
        else:
            # Convert the digit character to an integer
            digit_value = int(char) - int('0')
            amount_str += str(digit_value)

    # Convert the amount string to an integer
    amount = int(amount_str)

    # Perform the operation
    if operation == "D":
        netAmount += amount
    elif operation == "W":
        netAmount -= amount
    else:
        pass

print(netAmount)

def fibonacci(n):
    if n <= 0:
        return "Please enter a positive integer for n."
    elif n == 1:
        return 0
    elif n == 2:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

# Test the function
n = int(input("Enter the value of n: "))
result = fibonacci(n)
print(f"The {n}th value in the Fibonacci sequence is: {result}")

def format_number(number):
    if number < 0:
        return "Please enter a non-negative number."

    result = ""

    count = 0
    while number > 0:
        digit = number % 10
        number //= 10

        if count == 3:
            result = "," + result
            count = 0

        result = str(digit) + result
        count += 1

    return result

# Test the function
num = 1000000
formatted_num = format_number(num)
print("Original Number:", num)
print("Formatted Number:", formatted_num)

def param_count(*args):
    count = 0
    for _ in args:
        count += 1
    return count

# Test the function
print(param_count())          # Output: 0
print(param_count(2, 3, 4))    # Output: 3
print(param_count('a', 'b'))   # Output: 2

def collatz_steps(n):
    steps = 0
    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = 3 * n + 1
        steps += 1
    return steps

def compare_collatz_steps(a, b):
    steps_a = collatz_steps(a)
    steps_b = collatz_steps(b)

    if steps_a < steps_b:
        return str(a)
    else:
        return str(b)

# Test the function
result = compare_collatz_steps(6, 9)
print(result)  # Output: "6"

def nthTribonacci(n):
    prev3 = 0
    prev2 = 0
    prev1 = 1
    
    print(prev3, prev2, prev1, end=" ")

    for i in range(4, n + 1):
        curr = prev1 + prev2 + prev3
        print(curr, end=" ")
        prev3 = prev2
        prev2 = prev1
        prev1 = curr

n = 20
print(f'The first {n} Tribonacci Numbers are:', end=" ")
nthTribonacci(n)

# Tribonacci Series in python
# nth tribonacci number

def nthTribonacci(n):
    prev3=0
    prev2=0
    prev1 = 1
    for i in range(4,n+1):
        curr = prev1+prev2+prev3
        prev3 = prev2
        prev2 = prev1
        prev1 = curr
    return prev1

n = 18
nthTribonacciNumber = nthTribonacci(n)
print(f'The {n}th Tribonacci Number is:',nthTribonacciNumber)